Theoretically someone could pass null for T. In the current codepaths this would possibly be blocked at isTypeCompatible, but I think it's probably better to avoid the !!. We could do something like:

defaultValue?.let { it.class.simpleName ?: "Unknown" } ?: "Unknown"

or even directly return "Unknown" depending how important it is to know the exact class name.

Specification says that even for concrete methods above we need to return ResolutionDetails https://openfeature.dev/specification/sections/providers, but we are returning just the objects. Is it fine to not use this structure there?

Should we support nullable types (values) here? If it is not the case, type should be T : Any

I think this is confusing: here we have 3 resolveXXX methods, and the fact that there is resolveInternal with a result passed to resolveTracked doesn't add clarity. Should resolveInternal be renamed, maybe?

minor: it is better to move this up, so that we have interface methods grouped first and only after them we have private methods.

do we need to explicitly make return type nullable? Cannot we return empty collection if JSONObject is empty?

maybe it is worth to log it with MAINTAINER target?

should we also check for VariationType.NUMBER here as below?

I think this one can be just { s: String -> s }: input and output types are the same, to cast is not needed

we still have the usage of double term in API, should we keep it here? Or is it the change per spec?

Can value be null? If not, it is better to do data class ResolutionDetails<T: Any>

If value is never null, you should make T: Any everywhere like I described here https://github.com/DataDog/dd-sdk-android/pull/2923/files#r2444011674

I only see that FLAG_NOT_FOUND, PARSE_ERROR and TYPE_MISMATCH are used in this PR. Will others be used in other PRs or are they not needed?

e.g., "TARGETING_MATCH", "DEFAULT", "ERROR"

Is it possible to make this a enum instead of a String?

@Suppress("UNCHECKED_CAST")

this is not needed here

nit

You don't actually need a defaultValue here. You can pass the class itself using KClass.

internal object FlagValueConverter {

    fun <T : Any> convert(variationValue: String, variationType: String, resultType: KClass<T>): T? {
        if (!isTypeCompatible(variationType, resultType)) {
            return null
        }
        return try {
            doConvert(variationValue, resultType)
        } catch (
            @Suppress("TooGenericExceptionCaught", "SwallowedException")
            e: Exception
        ) {
            null
        }
    }

    fun isTypeCompatible(variationType: String, resultType: KClass<*>): Boolean = when (resultType) {
        Boolean::class -> variationType == VariationType.BOOLEAN.value
        String::class -> variationType == VariationType.STRING.value
        Int::class -> variationType == VariationType.INTEGER.value
        Double::class -> variationType == VariationType.NUMBER.value || variationType == VariationType.FLOAT.value
        JSONObject::class -> variationType == VariationType.OBJECT.value
        else -> false
    }
    
    @Suppress("UNCHECKED_CAST")
    private fun <T : Any> doConvert(s: String, resultType: KClass<T>): T? = when (resultType) {
        Boolean::class -> s.lowercase(Locale.US).toBooleanStrictOrNull() as? T
        String::class -> s as? T
        Int::class -> s.toIntOrNull() as? T
        Double::class -> s.toDoubleOrNull() as? T
        JSONObject::class -> JSONObject(s) as? T
        else -> null
    }

    fun getTypeName(type: KClass<*>): String = when (type) {
        Boolean::class -> "Boolean"
        String::class -> "String"
        Int::class -> "Int"
        Double::class -> "Double"
        JSONObject::class -> "JSONObject"
        else -> type.simpleName ?: "Unknown"
    }
}